{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import tqdm\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import *\n",
    "from tensorflow.keras.layers import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9568, 5)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AT</th>\n",
       "      <th>V</th>\n",
       "      <th>AP</th>\n",
       "      <th>RH</th>\n",
       "      <th>PE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>14.96</td>\n",
       "      <td>41.76</td>\n",
       "      <td>1024.07</td>\n",
       "      <td>73.17</td>\n",
       "      <td>463.26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>25.18</td>\n",
       "      <td>62.96</td>\n",
       "      <td>1020.04</td>\n",
       "      <td>59.08</td>\n",
       "      <td>444.37</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>5.11</td>\n",
       "      <td>39.40</td>\n",
       "      <td>1012.16</td>\n",
       "      <td>92.14</td>\n",
       "      <td>488.56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>20.86</td>\n",
       "      <td>57.32</td>\n",
       "      <td>1010.24</td>\n",
       "      <td>76.64</td>\n",
       "      <td>446.48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>10.82</td>\n",
       "      <td>37.50</td>\n",
       "      <td>1009.23</td>\n",
       "      <td>96.62</td>\n",
       "      <td>473.90</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      AT      V       AP     RH      PE\n",
       "0  14.96  41.76  1024.07  73.17  463.26\n",
       "1  25.18  62.96  1020.04  59.08  444.37\n",
       "2   5.11  39.40  1012.16  92.14  488.56\n",
       "3  20.86  57.32  1010.24  76.64  446.48\n",
       "4  10.82  37.50  1009.23  96.62  473.90"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### READ DATA ###\n",
    "\n",
    "df = pd.read_excel('Folds5x2_pp.xlsx')\n",
    "\n",
    "print(df.shape)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c329003550>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### PLOT CORRELATION MATRIX ###\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "train_size = int(df.shape[0]*0.8)\n",
    "corr_matrix = df.iloc[:train_size,:].corr().abs()\n",
    "sns.heatmap(corr_matrix, mask=np.zeros_like(corr_matrix, dtype=np.bool), cmap=sns.diverging_palette(220, 10, as_cmap=True),\n",
    "            square=True, annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "### TRAIN TEST SPLIT ###\n",
    "\n",
    "X, y = ['AT','V','AP','RH'], ['PE']\n",
    "X_train, X_test, y_train, y_test = train_test_split(df[X], df[y], test_size = 0.2, random_state = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GRADIENT BOOSTING FEATURE IMPORTANCES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingRegressor(alpha=0.9, ccp_alpha=0.0, criterion='friedman_mse',\n",
       "                          init=None, learning_rate=0.1, loss='ls', max_depth=3,\n",
       "                          max_features=None, max_leaf_nodes=None,\n",
       "                          min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                          min_samples_leaf=1, min_samples_split=2,\n",
       "                          min_weight_fraction_leaf=0.0, n_estimators=100,\n",
       "                          n_iter_no_change=None, presort='deprecated',\n",
       "                          random_state=None, subsample=1.0, tol=0.0001,\n",
       "                          validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### FIT GRADIENTBOOSTING ###\n",
    "\n",
    "gb = GradientBoostingRegressor(n_estimators=100)\n",
    "gb.fit(X_train, y_train.values.ravel())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9478745857816366"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### PREDICTION ERROR ON TEST DATA ###\n",
    "\n",
    "mean_absolute_error(y_test, gb.predict(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### FEATURE IMPORTANCES REPORT ###\n",
    "\n",
    "plt.bar(range(X_train.shape[1]), gb.feature_importances_)\n",
    "plt.xticks(range(X_train.shape[1]), ['AT','V','AP','RH'])\n",
    "np.set_printoptions(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PERMUTATION IMPORTANCE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "### SCALE DATA FOR NN ###\n",
    "\n",
    "scaler = StandardScaler()\n",
    "scaled_train = scaler.fit_transform(X_train)\n",
    "scaled_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "### UTILITY FUNCTIONS TO SCALE TARGET ###\n",
    "\n",
    "mean_train = y_train.mean().values\n",
    "std_train = y_train.std().values\n",
    "\n",
    "def scale_target(y, mean, std):\n",
    "    return np.asarray((y - mean)/std)\n",
    "\n",
    "def reverse_target(pred, mean, std): \n",
    "    return np.asarray(pred*std + mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 7654 samples\n",
      "Epoch 1/100\n",
      "7654/7654 - 1s - loss: 0.2597\n",
      "Epoch 2/100\n",
      "7654/7654 - 0s - loss: 0.0659\n",
      "Epoch 3/100\n",
      "7654/7654 - 0s - loss: 0.0618\n",
      "Epoch 4/100\n",
      "7654/7654 - 0s - loss: 0.0608\n",
      "Epoch 5/100\n",
      "7654/7654 - 0s - loss: 0.0599\n",
      "Epoch 6/100\n",
      "7654/7654 - 0s - loss: 0.0599\n",
      "Epoch 7/100\n",
      "7654/7654 - 0s - loss: 0.0595\n",
      "Epoch 8/100\n",
      "7654/7654 - 0s - loss: 0.0588\n",
      "Epoch 9/100\n",
      "7654/7654 - 0s - loss: 0.0584\n",
      "Epoch 10/100\n",
      "7654/7654 - 0s - loss: 0.0587\n",
      "Epoch 11/100\n",
      "7654/7654 - 0s - loss: 0.0581\n",
      "Epoch 12/100\n",
      "7654/7654 - 0s - loss: 0.0581\n",
      "Epoch 13/100\n",
      "7654/7654 - 0s - loss: 0.0575\n",
      "Epoch 14/100\n",
      "7654/7654 - 0s - loss: 0.0574\n",
      "Epoch 15/100\n",
      "7654/7654 - 0s - loss: 0.0574\n",
      "Epoch 16/100\n",
      "7654/7654 - 0s - loss: 0.0575\n",
      "Epoch 17/100\n",
      "7654/7654 - 0s - loss: 0.0571\n",
      "Epoch 18/100\n",
      "7654/7654 - 0s - loss: 0.0569\n",
      "Epoch 19/100\n",
      "7654/7654 - 0s - loss: 0.0573\n",
      "Epoch 20/100\n",
      "7654/7654 - 0s - loss: 0.0563\n",
      "Epoch 21/100\n",
      "7654/7654 - 0s - loss: 0.0564\n",
      "Epoch 22/100\n",
      "7654/7654 - 0s - loss: 0.0561\n",
      "Epoch 23/100\n",
      "7654/7654 - 0s - loss: 0.0565\n",
      "Epoch 24/100\n",
      "7654/7654 - 0s - loss: 0.0560\n",
      "Epoch 25/100\n",
      "7654/7654 - 0s - loss: 0.0555\n",
      "Epoch 26/100\n",
      "7654/7654 - 0s - loss: 0.0559\n",
      "Epoch 27/100\n",
      "7654/7654 - 0s - loss: 0.0554\n",
      "Epoch 28/100\n",
      "7654/7654 - 0s - loss: 0.0552\n",
      "Epoch 29/100\n",
      "7654/7654 - 0s - loss: 0.0553\n",
      "Epoch 30/100\n",
      "7654/7654 - 0s - loss: 0.0550\n",
      "Epoch 31/100\n",
      "7654/7654 - 0s - loss: 0.0549\n",
      "Epoch 32/100\n",
      "7654/7654 - 0s - loss: 0.0550\n",
      "Epoch 33/100\n",
      "7654/7654 - 0s - loss: 0.0552\n",
      "Epoch 34/100\n",
      "7654/7654 - 0s - loss: 0.0548\n",
      "Epoch 35/100\n",
      "7654/7654 - 0s - loss: 0.0544\n",
      "Epoch 36/100\n",
      "7654/7654 - 0s - loss: 0.0550\n",
      "Epoch 37/100\n",
      "7654/7654 - 0s - loss: 0.0547\n",
      "Epoch 38/100\n",
      "7654/7654 - 0s - loss: 0.0546\n",
      "Epoch 39/100\n",
      "7654/7654 - 0s - loss: 0.0543\n",
      "Epoch 40/100\n",
      "7654/7654 - 0s - loss: 0.0543\n",
      "Epoch 41/100\n",
      "7654/7654 - 0s - loss: 0.0539\n",
      "Epoch 42/100\n",
      "7654/7654 - 0s - loss: 0.0538\n",
      "Epoch 43/100\n",
      "7654/7654 - 0s - loss: 0.0547\n",
      "Epoch 44/100\n",
      "7654/7654 - 0s - loss: 0.0537\n",
      "Epoch 45/100\n",
      "7654/7654 - 0s - loss: 0.0535\n",
      "Epoch 46/100\n",
      "7654/7654 - 0s - loss: 0.0535\n",
      "Epoch 47/100\n",
      "7654/7654 - 0s - loss: 0.0539\n",
      "Epoch 48/100\n",
      "7654/7654 - 0s - loss: 0.0536\n",
      "Epoch 49/100\n",
      "7654/7654 - 0s - loss: 0.0535\n",
      "Epoch 50/100\n",
      "7654/7654 - 0s - loss: 0.0533\n",
      "Epoch 51/100\n",
      "7654/7654 - 0s - loss: 0.0535\n",
      "Epoch 52/100\n",
      "7654/7654 - 0s - loss: 0.0536\n",
      "Epoch 53/100\n",
      "7654/7654 - 0s - loss: 0.0539\n",
      "Epoch 54/100\n",
      "7654/7654 - 0s - loss: 0.0537\n",
      "Epoch 55/100\n",
      "7654/7654 - 0s - loss: 0.0532\n",
      "Epoch 56/100\n",
      "7654/7654 - 0s - loss: 0.0533\n",
      "Epoch 57/100\n",
      "7654/7654 - 0s - loss: 0.0533\n",
      "Epoch 58/100\n",
      "7654/7654 - 0s - loss: 0.0526\n",
      "Epoch 59/100\n",
      "7654/7654 - 0s - loss: 0.0529\n",
      "Epoch 60/100\n",
      "7654/7654 - 0s - loss: 0.0532\n",
      "Epoch 61/100\n",
      "7654/7654 - 0s - loss: 0.0526\n",
      "Epoch 62/100\n",
      "7654/7654 - 0s - loss: 0.0529\n",
      "Epoch 63/100\n",
      "7654/7654 - 0s - loss: 0.0526\n",
      "Epoch 64/100\n",
      "7654/7654 - 0s - loss: 0.0522\n",
      "Epoch 65/100\n",
      "7654/7654 - 0s - loss: 0.0525\n",
      "Epoch 66/100\n",
      "7654/7654 - 0s - loss: 0.0521\n",
      "Epoch 67/100\n",
      "7654/7654 - 0s - loss: 0.0525\n",
      "Epoch 68/100\n",
      "7654/7654 - 0s - loss: 0.0524\n",
      "Epoch 69/100\n",
      "7654/7654 - 0s - loss: 0.0519\n",
      "Epoch 70/100\n",
      "7654/7654 - 0s - loss: 0.0521\n",
      "Epoch 71/100\n",
      "7654/7654 - 0s - loss: 0.0532\n",
      "Epoch 72/100\n",
      "7654/7654 - 0s - loss: 0.0525\n",
      "Epoch 73/100\n",
      "7654/7654 - 0s - loss: 0.0517\n",
      "Epoch 74/100\n",
      "7654/7654 - 0s - loss: 0.0519\n",
      "Epoch 75/100\n",
      "7654/7654 - 0s - loss: 0.0524\n",
      "Epoch 76/100\n",
      "7654/7654 - 0s - loss: 0.0519\n",
      "Epoch 77/100\n",
      "7654/7654 - 0s - loss: 0.0521\n",
      "Epoch 78/100\n",
      "7654/7654 - 0s - loss: 0.0522\n",
      "Epoch 79/100\n",
      "7654/7654 - 0s - loss: 0.0524\n",
      "Epoch 80/100\n",
      "7654/7654 - 0s - loss: 0.0521\n",
      "Epoch 81/100\n",
      "7654/7654 - 0s - loss: 0.0518\n",
      "Epoch 82/100\n",
      "7654/7654 - 0s - loss: 0.0521\n",
      "Epoch 83/100\n",
      "7654/7654 - 0s - loss: 0.0513\n",
      "Epoch 84/100\n",
      "7654/7654 - 0s - loss: 0.0519\n",
      "Epoch 85/100\n",
      "7654/7654 - 0s - loss: 0.0514\n",
      "Epoch 86/100\n",
      "7654/7654 - 0s - loss: 0.0516\n",
      "Epoch 87/100\n",
      "7654/7654 - 0s - loss: 0.0515\n",
      "Epoch 88/100\n",
      "7654/7654 - 0s - loss: 0.0512\n",
      "Epoch 89/100\n",
      "7654/7654 - 0s - loss: 0.0509\n",
      "Epoch 90/100\n",
      "7654/7654 - 0s - loss: 0.0517\n",
      "Epoch 91/100\n",
      "7654/7654 - 0s - loss: 0.0512\n",
      "Epoch 92/100\n",
      "7654/7654 - 0s - loss: 0.0513\n",
      "Epoch 93/100\n",
      "7654/7654 - 0s - loss: 0.0508\n",
      "Epoch 94/100\n",
      "7654/7654 - 0s - loss: 0.0514\n",
      "Epoch 95/100\n",
      "7654/7654 - 0s - loss: 0.0509\n",
      "Epoch 96/100\n",
      "7654/7654 - 0s - loss: 0.0513\n",
      "Epoch 97/100\n",
      "7654/7654 - 0s - loss: 0.0508\n",
      "Epoch 98/100\n",
      "7654/7654 - 0s - loss: 0.0504\n",
      "Epoch 99/100\n",
      "7654/7654 - 0s - loss: 0.0509\n",
      "Epoch 100/100\n",
      "7654/7654 - 0s - loss: 0.0520\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1c32b55d358>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def set_seed(seed):\n",
    "    \n",
    "    tf.random.set_seed(seed)\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "\n",
    "\n",
    "set_seed(33)\n",
    "\n",
    "inp = Input(shape=(scaled_train.shape[1],))\n",
    "x = Dense(128, activation='relu')(inp)\n",
    "x = Dense(32, activation='relu')(x)\n",
    "out = Dense(1)(x)\n",
    "model = Model(inp, out)\n",
    "\n",
    "model.compile(optimizer='adam', loss='mse')\n",
    "model.fit(scaled_train, scale_target(y_train, mean_train, std_train) , epochs=100, batch_size=128 ,verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9543382479367595"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### PREDICTION ERROR ON TEST DATA ###\n",
    "\n",
    "real_pred = reverse_target(model.predict(scaled_test).ravel(), mean_train, std_train) \n",
    "MAE = mean_absolute_error(y_test, real_pred)\n",
    "\n",
    "MAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([17.,  6.,  4.,  4.])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### COMPUTE PERMUTATION AND SCORING ###\n",
    "\n",
    "os.environ['PYTHONHASHSEED'] = str(33)\n",
    "np.random.seed(33)\n",
    "random.seed(33)\n",
    "\n",
    "final_score = []\n",
    "shuff_pred = []\n",
    "\n",
    "for i,col in enumerate(X_test.columns):\n",
    "\n",
    "    # shuffle column\n",
    "    shuff_test = scaled_test.copy()\n",
    "    shuff_test[:,i] = np.random.permutation(shuff_test[:,i])\n",
    "    \n",
    "    # compute score\n",
    "    score = mean_absolute_error(y_test, reverse_target(model.predict(shuff_test).ravel(), mean_train, std_train))\n",
    "    shuff_pred.append(reverse_target(model.predict(shuff_test).ravel(), mean_train, std_train))\n",
    "    final_score.append(score)\n",
    "    \n",
    "final_score = np.asarray(final_score)\n",
    "final_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### PERMUTATION IMPORTANCE REPORT ###\n",
    "\n",
    "plt.bar(range(X_train.shape[1]), (final_score - MAE)/MAE*100)\n",
    "plt.xticks(range(X_train.shape[1]), ['AT','V','AP','RH'])\n",
    "np.set_printoptions(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EXPLAIN CASUALITY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0253"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### SIMULATE MEAN DIFFERENCE TEST AMONG PREDICTIONS ###\n",
    "\n",
    "os.environ['PYTHONHASHSEED'] = str(33)\n",
    "np.random.seed(33)\n",
    "random.seed(33)\n",
    "\n",
    "id_ = 0\n",
    "\n",
    "merge_pred = np.hstack([shuff_pred[id_], real_pred])\n",
    "observed_diff = abs(shuff_pred[id_].mean() - merge_pred.mean())\n",
    "extreme_values = []\n",
    "sample_d = []\n",
    "\n",
    "for _ in range(10000):\n",
    "    sample_mean = np.random.choice(merge_pred, size=shuff_pred[id_].shape[0]).mean()\n",
    "    sample_diff = abs(sample_mean - merge_pred.mean())\n",
    "    sample_d.append(sample_diff)\n",
    "    extreme_values.append(sample_diff >= observed_diff)\n",
    "    \n",
    "np.sum(extreme_values)/10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.LineCollection at 0x1c32b8f0f28>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### PLOT MEAN DIFFERENCE DISTRIBUTIONS ###\n",
    "\n",
    "y, x, _ = plt.hist(sample_d, alpha=0.6)\n",
    "plt.vlines(observed_diff, 0,max(y), colors='red', linestyles='dashed')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
